/**
 * Boltron 渲染进程桥接器
 */

// 从窗口对象获取 electron API
const electronAPI = (window as any).electron || {};

// 从窗口对象获取 boltron API
const boltron = (window as any).boltron || {
  exposeRendererApi: () => console.warn('BoltronRenderer: 预加载脚本未加载，无法注册渲染进程 API')
};

/**
 * 渲染进程 API 接口
 */
export interface RendererApi {
  [namespace: string]: {
    [methodName: string]: (...args: any[]) => any;
  };
}

/**
 * Boltron 渲染进程桥接器
 */
export class BoltronRenderer {
  /**
   * 调用主进程方法
   * @param method 方法名称，格式为 `namespace:method`
   * @param args 参数列表
   * @returns Promise 包装的结果
   */
  public static callMain<T>(method: string, ...args: any[]): Promise<T> {
    // 解析方法名称
    const [namespace, methodName] = method.split(':');
    
    // 确保方法存在
    if (!electronAPI[namespace] || !electronAPI[namespace][methodName]) {
      return Promise.reject(new Error(`BoltronRenderer: 方法 ${method} 不存在`));
    }
    
    // 调用方法
    return electronAPI[namespace][methodName](...args);
  }

  /**
   * 暴露渲染进程 API 给主进程
   * @param api 渲染进程 API
   */
  public static exposeRendererApi(api: RendererApi): void {
    boltron.exposeRendererApi(api);
  }

  /**
   * 获取可用的主进程 API 列表
   */
  public static getAvailableAPIs(): string[] {
    const apis: string[] = [];
    
    for (const namespace of Object.keys(electronAPI)) {
      if (typeof electronAPI[namespace] === 'object') {
        for (const method of Object.keys(electronAPI[namespace])) {
          if (typeof electronAPI[namespace][method] === 'function') {
            apis.push(`${namespace}:${method}`);
          }
        }
      }
    }
    
    return apis;
  }
} 